﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;

namespace Tetris_AntiGravity
{
    public class Figura
    {
        //posición inicial de la figura
        public Vector2 posicion;

        //guarda el color de la figura
        public Color color { get; set; }

        public Texture2D texturaColor { get; set; }
        private Game game;

        //Variable para generar aleatoreamente el tipo de figura
        private Random mRandom = new Random(DateTime.Now.Millisecond);

        //se guarda la rotacion actual de la figura
        public Int32 rotacion=0;

        //tamaño del bloque en pixeles
        public Int32 tamanoBloque = 32;
        
        //Estructura para generar el tipo de figura
        

        //variable para almacenar que tipo de figura es
        private TipoFigura ftipo;

        //variable publica para el manejo del tipo de variable
        public TipoFigura tipo
        {
            get
            {
                return ftipo;
            }
            set
            {
                ftipo = value;
                switch (ftipo)
                {
                    case TipoFigura.FiguraT:
                        {
                            FiguraActual = FiguraT;
                            color = Color.Blue;
                            break;
                        }
                    case TipoFigura.FiguraI:
                        {
                            FiguraActual = FiguraI;
                            color = Color.Orange;
                            break;
                        }
                    case TipoFigura.FiguraJ:
                        {
                            FiguraActual = FiguraJ;
                            color = Color.Aquamarine;
                            break;
                        }
                    case TipoFigura.FiguraL:
                        {
                            FiguraActual = FiguraL;
                            color = Color.Cyan;
                            break;
                        }
                    case TipoFigura.FiguraS:
                        {
                            FiguraActual = FiguraS;
                            color = Color.DeepSkyBlue;
                            break;
                        }
                    case TipoFigura.FiguraZ:
                        {
                            FiguraActual = FiguraZ;
                            color = Color.LightPink;
                            break;
                        }
                    case TipoFigura.FiguraO:
                        {
                            FiguraActual = FiguraO;
                            color = Color.LimeGreen;
                            break;
                        }
                }
            }
        }

        //matriz para el manejo de la figura actual
        public Int32[, ,] FiguraActual { get; set; }

        
        //matrices en las que se guadan las posiciones donde van bloques
        public int[, ,] FiguraT = new int[4, 4, 2] 
                {
                 {
                  {1, 2}, {0, 3}, {1, 3}, {2, 3}
                 }, 
                 {
                  {1, 1}, {1, 2}, {1, 3}, {0, 2}
                }, 
                {
                 {0, 2}, {1, 2}, {2, 2}, {1, 3}
                }, 
                {
                 {0, 1}, {0, 2}, {0, 3}, {1, 2}
                }
               };
        public int[, ,] FiguraI = new int[4, 4, 2]
                {
                 {
                  {0, 3}, {1, 3}, {2, 3}, {3, 3} 
                 
                 }, 
                 {
                  {0, 0}, {0, 1}, {0, 2}, {0, 3}
                 }, 
                 {
                  {0, 3}, {1, 3}, {2, 3}, {3, 3} 
                 
                 }, 
                 {
                  {0, 0}, {0, 1}, {0, 2}, {0, 3}
                 }
                };

        public int[, ,] FiguraO = new int[4, 4, 2] 
              { 
               {
                {0, 2}, {1, 2}, {0, 3}, {1, 3}
               }, 
               {
                {0, 2}, {1, 2}, {0, 3}, {1, 3}
               }, 
               {
                {0, 2}, {1, 2}, {0, 3}, {1, 3}
               }, 
               {
                {0, 2}, {1, 2}, {0, 3}, {1, 3}
               } 
              };

        public int[, ,] FiguraZ = new int[4, 4, 2] 
              { 
               {
                {0, 2}, {1, 2}, {1, 3}, {2, 3}
               }, 
               {
                {1, 1}, {1, 2}, {0, 2}, {0, 3}
               }, 
               {
                {0, 2}, {1, 2}, {1, 3}, {2, 3}
               }, 
               {
                {1, 1}, {1, 2}, {0, 2}, {0, 3}
               } 
              };

        public int[, ,] FiguraS = new int[4, 4, 2] 
            { 
             {
              {1, 2}, {2, 2}, {0, 3}, {1, 3}
             }, 
             {
              {0, 1}, {0, 2}, {1, 2}, {1, 3}
             }, 
             {
              {1, 2}, {2, 2}, {0, 3}, {1, 3}
             }, 
             {
              {0, 1}, {0, 2}, {1, 2}, {1, 3}
             } 
            };

        public int[, ,] FiguraJ = new int[4, 4, 2] 
                  { 
               {
                {0, 2}, {0, 3}, {1, 3}, {2, 3}
               }, 
               {
                {1, 1}, {1, 2}, {1, 3}, {0, 3}
               }, 
               {
                {0, 2}, {1, 2}, {2, 2}, {2, 3}
               }, 
               {
                {0, 1}, {1, 1}, {0, 2}, {0, 3}
               } 
              };

        public int[, ,] FiguraL = new int[4, 4, 2] 
              { 
               {
                {0, 3}, {1, 3}, {2, 3}, {2, 2}
               }, 
               {
                {0, 1}, {1, 1}, {1, 2}, {1, 3}
               }, 
               {
                {0, 2}, {1, 2}, {2, 2}, {0, 3}
               }, 
               {
                {0, 1}, {0, 2}, {0, 3}, {1, 3}
               } 
              };

        //constructor
        public Figura(Game game)
        {
            tamanoBloque = 32;
            posicion = new Vector2(4, 13);
            this.game = game;
            //texturaColor = game.Content.Load<Texture2D>(@"bloques/amarillo");
            tipo = seleccionarFigura();
            escogerTextura();
            //tipo = TipoFigura.FiguraL;

        }
        
        //se selecciona de manera aleatoria una nueva figura
        public TipoFigura seleccionarFigura()
        {
            return ((TipoFigura)(mRandom.Next(0, 6 + 1)));
        }

        //Dibuja el bloque en pantalla
        public void Draw(Vector2 _Posicion, SpriteBatch theSpriteBatch)
        {
            //ciclo que recorre la matriz de la figura y la dibuja
            for (Int32 aBloque = 0; aBloque < 4; aBloque++)
            {
                int aXPosicion = ((Int32)(_Posicion.X + (FiguraActual[rotacion, aBloque, 0] * tamanoBloque)));
                int aYPosicion = (Int32)(_Posicion.Y + (FiguraActual[rotacion, aBloque, 1] * tamanoBloque));
                escogerTextura();
                theSpriteBatch.Draw(texturaColor, new Rectangle(aXPosicion, aYPosicion, tamanoBloque, tamanoBloque), Color.White);
            }
        }

        private void escogerTextura() {
            if (tipo == TipoFigura.FiguraI)
                texturaColor = game.Content.Load<Texture2D>(@"bloques/amarillo");
            else if (tipo == TipoFigura.FiguraJ)
                texturaColor = game.Content.Load<Texture2D>(@"bloques/aqua");
            else if (tipo == TipoFigura.FiguraL)
                texturaColor = game.Content.Load<Texture2D>(@"bloques/azul");
            else if (tipo == TipoFigura.FiguraO)
                texturaColor = game.Content.Load<Texture2D>(@"bloques/naranja");
            else if (tipo == TipoFigura.FiguraS)
                texturaColor = game.Content.Load<Texture2D>(@"bloques/purpura");
            else if (tipo == TipoFigura.FiguraT)
                texturaColor = game.Content.Load<Texture2D>(@"bloques/rojo");
            else
                texturaColor = game.Content.Load<Texture2D>(@"bloques/verde");
        }
    }
}
